﻿#pragma once
#ifndef WRDATAHANDLERS_H
#define WRDATAHANDLERS_H

#include "../Structs/WRObservers.h"
#include "WRDataSource.h"

//表示数据处理器集合。
template <class TArgs, class TData>
class WRDataHandlers : public WRObservers<WRDataHandler>, public WRDataSource
{
protected:
    //参数内容。
    TArgs m_params;
    //当前状态。
    bool m_status;

    //当指定的观察者添加后调用此方法。
    void onAdded(Observer observer)
    {
        if (m_status)
        {
            observer->onStarted(&m_params);
        }
    }
    //当指定的观察者移除后调用此方法。
    void onRemoved(Observer observer)
    {
        if (m_status)
        {
            observer->onStopped();
        }
    }

public:
    //构造函数。
    WRDataHandlers() : m_status(false)
    {
        //add code here
    }

    //获取当前参数。
    inline void params(TArgs& value) const
    {
        value = m_params;
    }
    //获取当前参数。
    inline const TArgs& params(void) const
    {
        return m_params;
    }

    //判断当前是否启动。
    inline bool status(void) const
    {
        return m_status;
    }

    //当数据启动后调用此方法。
    void onStarted(const TArgs& args)
    {
        QMutexLocker lock(&m_mutex);
        for(WRu i = 0; i < m_count; ++i)
        {
            m_array[i]->onStarted(&args);
        }
        m_params = args;
        m_status = true;
    }
    //当数据启动后调用此方法。
    void onStarted(const TArgs* args)
    {
        QMutexLocker lock(&m_mutex);
        for(WRu i = 0; i < m_count; ++i)
        {
            m_array[i]->onStarted(args);
        }
        m_params = *args;
        m_status = true;
    }

    //当数据改变后调用此方法。
    void onChanged(const TArgs& args)
    {
        QMutexLocker lock(&m_mutex);
        for(WRu i = 0; i < m_count; ++i)
        {
            m_array[i]->onChanged(&args);
        }
        m_params = args;
        m_status = true;
    }
    //当数据改变后调用此方法。
    void onChanged(const TArgs* args)
    {
        QMutexLocker lock(&m_mutex);
        for(WRu i = 0; i < m_count; ++i)
        {
            m_array[i]->onChanged(args);
        }
        m_params = *args;
        m_status = true;
    }

    //当数据改变后调用此方法。
    void doProcess(const TData& data)
    {
        QMutexLocker lock(&m_mutex);
        if (m_status)
        {
            for(WRu i = 0; i < m_count; ++i)
            {
                m_array[i]->doProcess(&data);
            }
        }
    }
    //当数据改变后调用此方法。
    void doProcess(const TData* data)
    {
        QMutexLocker lock(&m_mutex);
        if (m_status)
        {
            for(WRu i = 0; i < m_count; ++i)
            {
                m_array[i]->doProcess(data);
            }
        }
    }

    //当数据停止后调用此方法。
    void onStopped(void)
    {
        QMutexLocker lock(&m_mutex);
        for(WRu i = 0; i < m_count; ++i)
        {
            m_array[i]->onStopped();
        }
        m_status = false;
    }

    //获取当前参数值。
    //如果已经启动，则能获取到参数值并返回True，否则返回False。
    bool current(TArgs& value) const
    {
        QMutexLocker lock(&m_mutex);
        if(m_status)
        {
            value = m_params;
            return true;
        }
        return false;
    }
    //获取当前参数值。
    //如果已经启动，则能获取到参数值并返回True，否则返回False。
    bool current(TArgs* value) const
    {
        QMutexLocker lock(&m_mutex);
        if(m_status)
        {
            *value = m_params;
            return true;
        }
        return false;
    }

private:
    //添加数据处理者。
    void addHandler(WRDataHandler* handler)
    {
        add(handler);
    }
    //移除数据处理者。
    bool removeHandler(WRDataHandler* handler)
    {
        return remove(handler);
    }
};

#endif // WRDATAHANDLERS_H

